home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Screenblankers / GBlanker / GSource / Blankers / Goats / blank.c next >
C/C++ Source or Header  |  1996-09-26  |  6KB  |  279 lines
  1. /*
  2.  *  Copyright (c) 1994 Steve "Goatboy" Akers
  3.  *  All rights reserved.
  4.  *
  5.  *  Please see the documentation accompanying the distribution for distribution
  6.  *  and disclaimer information.
  7.  */
  8.  
  9. #include <exec/memory.h>
  10. #include "/includes.h"
  11.  
  12. #define DELAY   0
  13. #define HERDERS 2
  14. #define GOATS   4
  15. #define REPRO   6
  16. #define SCREEN  8
  17. #define MODE    10
  18.  
  19. #define GOAT 1
  20. #define HERDER 2
  21. #define GRASS 3
  22.  
  23. typedef struct _Position
  24. {
  25.     LONG x;
  26.     LONG y;
  27. } Position;
  28.  
  29. LONG myBlank(struct Screen *LScr, UWORD Width, UWORD Height);
  30. void doGoats(struct RastPort *r);
  31. void doHerders(struct RastPort *r);
  32. LONG neighbor(struct RastPort *r, LONG dir);
  33.  
  34. Position    herders[512];
  35. LONG        herderQ[512] = {0};
  36. LONG        numHerders, herderClr;
  37. Position    goats[512];
  38. LONG        goatQ[512] = {0};
  39. LONG        grassEaten[512] = {0};
  40. LONG        numGoats, goatClr, reproduction;
  41. LONG        x,y,tx,ty, backgroundClr, grassClr;
  42. LONG        Width, Height;
  43.  
  44. #include "Goats_rev.h"
  45. STATIC const UBYTE VersTag[] = VERSTAG;
  46.  
  47. VOID Defaults( PrefObject *Prefs )
  48. {
  49.     Prefs[DELAY].po_Level = 0;
  50.     Prefs[HERDERS].po_Level = 40;
  51.     Prefs[GOATS].po_Level = 60;
  52.     Prefs[REPRO].po_Level = 2;
  53.     Prefs[SCREEN].po_Active = 0;
  54.     Prefs[MODE].po_ModeID = getTopScreenMode();
  55. }
  56.  
  57. LONG myBlank(struct Screen *LScr, UWORD Width, UWORD Height)
  58. {
  59.     struct RastPort *r;
  60.     
  61.     r = &( LScr->RastPort );
  62.     doHerders(r);
  63.     doGoats(r);
  64.     
  65.     return 0;
  66. }
  67.  
  68. void doHerders(struct RastPort *r)
  69. {
  70.     LONG    ptr = numHerders-1;
  71.     LONG    i,n,newX,newY,startDir,tmpDir;
  72.     LONG    flag = 0;
  73.     
  74.     while( ptr >= 0 ) {
  75.         if( herderQ[ptr] ) {
  76.             flag = 1;
  77.             x = herders[ptr].x;
  78.             y = herders[ptr].y;
  79.             SetAPen(r, grassClr);
  80.             WritePixel(r, x, y);
  81.             startDir = tmpDir  = (LONG)RangeRand(8);
  82.             while (1) {
  83.                 n = neighbor(r, tmpDir);
  84.                 if (n == grassClr || n == -1) {
  85.                     tmpDir = (tmpDir+1) % 8;
  86.                     if (tmpDir == startDir) {
  87.                         herderQ[ptr] = 0;
  88.                         break;
  89.                     }
  90.                 }
  91.                 else {
  92.                     herders[ptr].x = newX = tx;
  93.                     herders[ptr].y = newY = ty;
  94.                     i = 0;
  95.                     while(herderQ[i] && i < numHerders)
  96.                         ++i;
  97.                     if (i != numHerders) {
  98.                         herders[i].x = newX;
  99.                         herders[i].y = newY;
  100.                         herderQ[i] = 1;
  101.                     }
  102.                     SetAPen(r,herderClr);
  103.                     WritePixel(r,newX,newY);
  104.                     break;
  105.                 }
  106.             }
  107.         }
  108.         --ptr;
  109.     }
  110.     if (!flag) {
  111.         herderQ[0] = 1;
  112.         herders[0].x = (LONG)RangeRand(Width-1);
  113.         herders[0].y = (LONG)RangeRand(Height-1);
  114.     }
  115. }
  116.  
  117. void doGoats(struct RastPort *r)
  118. {
  119.     LONG    ptr = numGoats-1;
  120.     LONG    i,n,newX,newY,startDir,tmpDir;
  121.     LONG    flag = 0;
  122.  
  123.     while (ptr >= 0) {
  124.         if (goatQ[ptr] ) {
  125.             flag = 1;
  126.             x = goats[ptr].x;
  127.             y = goats[ptr].y;
  128.             SetAPen(r, backgroundClr);
  129.             WritePixel(r, x, y);
  130.             startDir = tmpDir  = (LONG)RangeRand(8);
  131.             while (1) {
  132.                 n = neighbor(r, tmpDir);
  133.                 if (n != grassClr || n == -1) {
  134.                     tmpDir = (tmpDir+1) % 8;
  135.                     if (tmpDir == startDir) {
  136.                         goatQ[ptr] = 0;
  137.                         break;
  138.                     }
  139.                 }
  140.                 else {
  141.                     goats[ptr].x = newX = tx;
  142.                     goats[ptr].y = newY = ty;
  143.                     ++grassEaten[ptr];
  144.                     if (grassEaten[ptr] >= reproduction) {
  145.                         grassEaten[ptr] = 0;
  146.                         i = 0;
  147.                         while(goatQ[i] != 0 && i < numGoats)
  148.                             ++i;
  149.                         if (i != numGoats) {
  150.                             goats[i].x = newX;
  151.                             goats[i].y = newY;
  152.                             goatQ[i] = 1;
  153.                             grassEaten[i] = 0;
  154.                         }
  155.                     }
  156.                     SetAPen(r,goatClr);
  157.                     WritePixel(r,newX,newY);
  158.                     break;
  159.                 }
  160.             }
  161.         }
  162.         --ptr;
  163.     }
  164.     if (!flag) {
  165.         goatQ[0] = 1;
  166.         goats[0].x = (LONG)RangeRand(Width-1);
  167.         goats[0].y = (LONG)RangeRand(Height-1);
  168.         grassEaten[0] = 0;
  169.     }
  170. }
  171.  
  172. LONG neighbor(struct RastPort *r, LONG dir)
  173. {
  174.     switch (dir) {
  175.     case 0:tx = x;ty = y+1;break;
  176.     case 1:tx = x+1;ty = y+1;break;
  177.     case 2:tx = x+1;ty = y;break;
  178.     case 3:tx = x+1;ty = y-1;break;
  179.     case 4:tx = x;ty = y-1;break;
  180.     case 5:tx = x-1;ty = y-1;break;
  181.     case 6:tx = x-1;ty = y;break;
  182.     case 7:tx = x-1;ty = y+1;break;
  183.     default: return -1;break;
  184.     }
  185.     if (tx < 0 || tx >= Width || ty < 0 || ty >= Height)
  186.         return -1; 
  187.     
  188.     return (LONG)ReadPixel(r, tx, ty);
  189. }
  190.  
  191. LONG Blank( PrefObject *Prefs )
  192. {
  193.     struct Screen *LScr;
  194.     struct Window *Wnd;
  195.     LONG RetVal = OK,i,goatFlag = 0, ToFrontCount = 0;
  196.     
  197.     if (Prefs[SCREEN].po_Active )
  198.         LScr = cloneTopScreen( FALSE, TRUE );
  199.     else
  200.         LScr = OpenScreenTags( 0l, SA_DisplayID, Prefs[MODE].po_ModeID,
  201.                               SA_Depth, 2, SA_Overscan, OSCAN_STANDARD,
  202.                               SA_Quiet, TRUE, SA_Behind, TRUE, TAG_DONE );
  203.     if( LScr )
  204.     {
  205.         if( GarshnelibBase->lib_Version < 39 || !Prefs[SCREEN].po_Active )
  206.         {
  207.             SetRGB4(&(LScr->ViewPort),0,0x0,0x0,0x0);
  208.             SetRGB4(&(LScr->ViewPort),1,0x8,0x8,0x8);
  209.             SetRGB4(&(LScr->ViewPort),2,0x7,0x4,0x2);
  210.             SetRGB4(&(LScr->ViewPort),3,0x0,0xa,0x0);
  211.             backgroundClr = 0;
  212.             grassClr = GRASS;
  213.             herderClr = HERDER;
  214.             goatClr = GOAT;
  215.         }
  216.         else
  217.         {
  218.             backgroundClr = FindColor( LScr->ViewPort.ColorMap, 0, 0, 0, -1 );
  219.             grassClr = FindColor( LScr->ViewPort.ColorMap, 0, 0x9L<<28, 0,
  220.                                  -1 );
  221.             goatClr = FindColor( LScr->ViewPort.ColorMap, 0xAL<<28, 0xAL<<28,
  222.                                 0xAL<<28, -1 );
  223.             herderClr = FindColor( LScr->ViewPort.ColorMap, 0xBL<<28, 0x2L<<28,
  224.                                   0x4L<<28, -1 );
  225.         }
  226.     
  227.         numGoats = Prefs[GOATS].po_Level;
  228.         numHerders = Prefs[HERDERS].po_Level;
  229.         reproduction = Prefs[REPRO].po_Level;
  230.         Width = LScr->Width;
  231.         Height = LScr->Height;
  232.         
  233.         for (i=0;i<numHerders;++i)
  234.             herderQ[i] = 0;
  235.         herderQ[0] = 1;
  236.         herders[0].x = Width/2;
  237.         herders[0].y = Height/2;
  238.         for (i=0;i<numGoats;++i)
  239.             goatQ[i] = 0;
  240.         
  241.         Wnd = BlankMousePointer( LScr );
  242.         ScreenToFront( LScr );
  243.         i = 0;
  244.         while( RetVal == OK )
  245.         {
  246.             WaitTOF();
  247.  
  248.             if(!( ++ToFrontCount % 60 ))
  249.                 ScreenToFront( LScr );
  250.             
  251.             if( !Prefs[DELAY].po_Level ||
  252.                !( ToFrontCount % Prefs[DELAY].po_Level ))
  253.             {
  254.                 myBlank( LScr, LScr->Width, LScr->Height );
  255.                 if (!goatFlag && i == 20)
  256.                 {
  257.                     goatQ[0] = 1;
  258.                     goats[0].x = Width/2;
  259.                     goats[0].y = Height/2;
  260.                     grassEaten[0] = 0;
  261.                     goatFlag = 1;
  262.                 }
  263.                 else
  264.                     ++i;
  265.             }
  266.  
  267.             RetVal = ContinueBlanking();
  268.         }
  269.  
  270.         UnblankMousePointer( Wnd );
  271.         CloseScreen( LScr );
  272.     }
  273.     else
  274.         RetVal = FAILED;
  275.     
  276.     return RetVal;
  277. }
  278.  
  279.